// 全局音频状态管理
let currentAudioContext = null;
let currentCleanupCallback = null;
let isPlaying = 0;

export default function speech(token, text) {
    // 在播放新音频前停止当前音频
    stopCurrentAudio();
    uni.showLoading({
        title: '语言合成中...',
    });
    uni.request({
        url: import.meta.env.VITE_COZE_URL + '/v1/audio/speech',
        method: 'POST',
        header: {
            Authorization: 'Bearer ' + token,
            'Content-Type': 'application/json',
        },
        data: {
            input: text,
            voice_id: '7426720361733144585',
        },
        // 设置响应类型为arraybuffer以接收二进制数据
        responseType: 'arraybuffer',
        success: res => {
            uni.hideLoading();
            if (res.statusCode !== 200) {
                uni.showToast({
                    title: '语言合成失败,请检查扣子账号',
                    icon: 'none',
                    duration: 2000,
                });
                return;
            }
            const audioData = res.data;
            // 播放mp3二进制数据
            playAudioFromBinary(audioData);
        },
        fail: err => {
            console.error('获取音频失败:', err);
            uni.showToast({
                title: '获取音频失败',
                icon: 'none',
                duration: 2000,
            });
            uni.hideLoading();
        },
    });
}

/**
 * 停止当前音频播放
 */
export function stopAudio() {
    stopCurrentAudio();
}

/**
 * 停止当前正在播放的音频
 */
function stopCurrentAudio() {
    if (currentAudioContext) {
        try {
            currentAudioContext.stop();
            currentAudioContext.destroy();
        } catch (error) {
            console.warn('停止音频时出错:', error);
        }
        currentAudioContext = null;
    }

    // 执行清理回调
    if (currentCleanupCallback) {
        try {
            currentCleanupCallback();
        } catch (error) {
            console.warn('执行清理回调时出错:', error);
        }
        currentCleanupCallback = null;
    }
}

/**
 * 播放二进制音频数据
 * @param {ArrayBuffer} audioData - mp3二进制数据
 */
function playAudioFromBinary(audioData) {
    try {
        // 创建音频上下文
        const innerAudioContext = uni.createInnerAudioContext();
        currentAudioContext = innerAudioContext;

        // 将ArrayBuffer转换为Base64
        const base64Data = arrayBufferToBase64(audioData);

        // 创建data URL
        const audioUrl = `data:audio/mpeg;base64,${base64Data}`;

        // 设置音频源
        innerAudioContext.src = audioUrl;

        // 设置音频属性
        innerAudioContext.autoplay = true;
        innerAudioContext.loop = false;

        // 监听播放事件
        innerAudioContext.onPlay(() => {
            console.log('开始播放音频');
            isPlaying = 1;
        });

        innerAudioContext.onEnded(() => {
            console.log('音频播放完成');
            // 清理全局状态
            if (currentAudioContext === innerAudioContext) {
                currentAudioContext = null;
                currentCleanupCallback = null;
            }
            innerAudioContext.destroy();
            isPlaying = 2;
        });

        innerAudioContext.onError(err => {
            console.error('音频播放错误:', err);
            // 清理全局状态
            if (currentAudioContext === innerAudioContext) {
                currentAudioContext = null;
                currentCleanupCallback = null;
            }
            uni.showToast({
                title: '音频播放失败',
                icon: 'none',
                duration: 2000,
            });
            innerAudioContext.destroy();
            isPlaying = 2;
        });

        // 在某些平台上可能需要手动调用play
        if (!innerAudioContext.autoplay) {
            innerAudioContext.play();
            isPlaying = 1;
        }
    } catch (error) {
        console.error('小程序音频播放处理失败:使用临时文件');
        // 如果Base64方法失败，尝试使用临时文件方法
        playAudioFromTempFile(audioData);
    }
}

/**
 * 使用临时文件播放音频（备用方案）
 * @param {ArrayBuffer} audioData - mp3二进制数据
 */
function playAudioFromTempFile(audioData) {
    try {
        // 针对不同平台使用不同的临时文件处理方式
        // #ifdef MP-WEIXIN
        // 微信小程序使用文件系统管理器
        const tempFilePath = `${wx.env.USER_DATA_PATH}/temp_audio_${Date.now()}.mp3`;
        const fs = wx.getFileSystemManager();
        fs.writeFileSync(tempFilePath, audioData);

        const wxCleanupCallback = () => {
            // 播放完成后清理临时文件
            try {
                fs.unlinkSync(tempFilePath);
            } catch (unlinkError) {
                console.warn('清理临时文件失败:', unlinkError);
            }
        };

        playAudioFromPath(tempFilePath, wxCleanupCallback);
        // #endif

        // #ifdef H5
        // H5环境使用Blob URL
        const blob = new Blob([audioData], { type: 'audio/mpeg' });
        const audioUrl = window.URL.createObjectURL(blob);

        const h5CleanupCallback = () => {
            // 播放完成后清理Blob URL
            window.URL.revokeObjectURL(audioUrl);
        };

        playAudioFromPath(audioUrl, h5CleanupCallback);
        // #endif

        // #ifdef APP-PLUS
        // APP环境使用plus.io
        const fileName = `temp_audio_${Date.now()}.mp3`;
        const filePath = plus.io.convertLocalFileSystemURL(`_doc/${fileName}`);

        // 写入文件
        plus.io.resolveLocalFileSystemURL('_doc/', entry => {
            entry.getFile(fileName, { create: true }, fileEntry => {
                fileEntry.createWriter(writer => {
                    writer.write(audioData);
                    writer.onwrite = () => {
                        const appCleanupCallback = () => {
                            // 播放完成后清理文件
                            fileEntry.remove();
                        };

                        playAudioFromPath(filePath, appCleanupCallback);
                    };
                });
            });
        });
        // #endif
    } catch (error) {
        console.error('临时文件音频播放失败:', error);
        uni.showToast({
            title: '音频播放失败',
            icon: 'none',
            duration: 2000,
        });
    }
}

/**
 * 从文件路径播放音频
 * @param {string} audioPath - 音频文件路径
 * @param {Function} onCleanup - 清理回调函数
 */
function playAudioFromPath(audioPath, onCleanup) {
    const innerAudioContext = uni.createInnerAudioContext();

    // 设置全局状态
    currentAudioContext = innerAudioContext;
    currentCleanupCallback = onCleanup;

    innerAudioContext.src = audioPath;
    innerAudioContext.autoplay = true;
    innerAudioContext.loop = false;

    innerAudioContext.onPlay(() => {
        console.log('开始播放音频（临时文件）');
    });

    innerAudioContext.onEnded(() => {
        console.log('音频播放完成（临时文件）');
        // 清理全局状态
        if (currentAudioContext === innerAudioContext) {
            currentAudioContext = null;
            currentCleanupCallback = null;
        }
        if (onCleanup) onCleanup();
        innerAudioContext.destroy();
        isPlaying = 2;
    });

    innerAudioContext.onError(err => {
        console.error('音频播放错误（临时文件）:', err);
        // 清理全局状态
        if (currentAudioContext === innerAudioContext) {
            currentAudioContext = null;
            currentCleanupCallback = null;
        }
        if (onCleanup) onCleanup();
        uni.showToast({
            title: '音频播放失败',
            icon: 'none',
            duration: 2000,
        });
        innerAudioContext.destroy();
        isPlaying = 2;
    });

    // 在某些平台上可能需要手动调用play
    if (!innerAudioContext.autoplay) {
        innerAudioContext.play();
        isPlaying = 1;
    }
}

/**
 * 将ArrayBuffer转换为Base64
 * @param {ArrayBuffer} buffer - 要转换的ArrayBuffer
 * @returns {string} Base64字符串
 */
function arrayBufferToBase64(buffer) {
    const bytes = new Uint8Array(buffer);
    let binary = '';
    for (let i = 0; i < bytes.byteLength; i++) {
        binary += String.fromCharCode(bytes[i]);
    }
    return btoa(binary);
}

/**
 * 获取当前音频播放状态
 * @returns {boolean} 是否正在播放
 */
export function isAudioPlaying() {
    return isPlaying;
}
